{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# The Very Basics of Musical Instruments Classification using Machine Learning\n",
    "## MFCC, SVM Grid Search\n",
    "\n",
    "<br>\n",
    "\n",
    "<p align=\"left\">\n",
    "<img src=\"./img/businesscard.jpg\" width=\"300px\" alt=\"Business Card\" align=\"left\" >\n",
    "</p>\n",
    "<br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/ZlxZ3i0RP9I\" frameborder=\"0\" \n",
       "allow=\"accelerometer; encrypted-media; gyroscope; picture-in-picture\"></iframe>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%html\n",
    "<iframe width=\"560\" height=\"315\" src=\"https://www.youtube.com/embed/ZlxZ3i0RP9I\" frameborder=\"0\" \n",
    "allow=\"accelerometer; encrypted-media; gyroscope; picture-in-picture\"></iframe>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports\n",
    "\n",
    "#General\n",
    "import numpy as np\n",
    "import pickle\n",
    "import itertools\n",
    "\n",
    "# System\n",
    "import os, fnmatch\n",
    "\n",
    "# Visualization\n",
    "import seaborn #visualization library, must be imported before all other plotting libraries\n",
    "import matplotlib.pyplot as plt\n",
    "from IPython.core.display import HTML, display\n",
    "\n",
    "# Machine Learning\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.model_selection import StratifiedShuffleSplit, GridSearchCV\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.metrics import recall_score, precision_score, accuracy_score\n",
    "from sklearn.metrics import confusion_matrix, f1_score, classification_report\n",
    "from sklearn.svm import LinearSVC, SVC\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# Random Seed\n",
    "from numpy.random import seed\n",
    "seed(1)\n",
    "\n",
    "# Audio\n",
    "import librosa.display, librosa\n",
    "\n",
    "# Configurations\n",
    "path='./audio/london_phill_dataset_multi/'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Auxiliary Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to Display a Website\n",
    "def show_web(url):\n",
    "    html_code='<center><iframe src=\"%s\" width=\"800\" height=\"600\" frameborder=\"0\" marginheight=\"0\" marginwidth=\"0\">Loading...</iframe></center>' \\\n",
    "\t\t% (url)\n",
    "    display(HTML(html_code))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Get filenames"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "found 600 audio files in ./audio/london_phill_dataset_multi/\n"
     ]
    }
   ],
   "source": [
    "# Get files in data path\n",
    "\n",
    "files = []\n",
    "for root, dirnames, filenames in os.walk(path):\n",
    "    for filename in fnmatch.filter(filenames, '*.mp3'):\n",
    "        files.append(os.path.join(root, filename))\n",
    "\n",
    "print(\"found %d audio files in %s\"%(len(files),path))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename=\"instruments_labels.pl\"\n",
    "# Load mfcc features from saved file\n",
    "with open(filename, \"rb\") as f:\n",
    "    classes_num = pickle.load( open( filename, \"rb\" ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters for MFCC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters\n",
    "# Signal Processing Parameters\n",
    "fs = 44100         # Sampling Frequency\n",
    "n_fft = 2048       # length of the FFT window\n",
    "hop_length = 512   # Number of samples between successive frames\n",
    "n_mels = 128       # Number of Mel bands\n",
    "n_mfcc = 13        # Number of MFCCs\n",
    "\n",
    "# Machine Learning Parameters\n",
    "testset_size = 0.25 #Percentage of data for Testing\n",
    "n_neighbors=1       # Number of neighbors for kNN Classifier"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save / Load Feature Vector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "filename=\"mfcc_feature_vectors.pl\"\n",
    "# Load mfcc features from saved file\n",
    "with open(filename, \"rb\") as f:\n",
    "    scaled_feature_vectors = pickle.load( open( filename, \"rb\" ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train and Test Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create Train and Test Set\n",
    "splitter = StratifiedShuffleSplit(n_splits=1, test_size=testset_size, random_state=0)\n",
    "splits = splitter.split(scaled_feature_vectors, classes_num)\n",
    "for train_index, test_index in splits:\n",
    "    train_set = scaled_feature_vectors[train_index]\n",
    "    test_set = scaled_feature_vectors[test_index]\n",
    "    train_classes = classes_num[train_index]\n",
    "    test_classes = classes_num[test_index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train_set shape: (450, 13)\n",
      "test_set shape: (150, 13)\n",
      "train_classes shape: (450,)\n",
      "test_classes shape: (150,)\n"
     ]
    }
   ],
   "source": [
    "# Check Set Shapes\n",
    "print(\"train_set shape:\",train_set.shape)\n",
    "print(\"test_set shape:\",test_set.shape)\n",
    "print(\"train_classes shape:\",train_classes.shape)\n",
    "print(\"test_classes shape:\",test_classes.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SVM Classification with Grid Search"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<center><iframe src=\"https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html\" width=\"800\" height=\"600\" frameborder=\"0\" marginheight=\"0\" marginwidth=\"0\">Loading...</iframe></center>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_web(\"https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SVM Grid Search\n",
    "C_range = np.logspace(-2, 10, 13)\n",
    "gamma_range = np.logspace(-9, 3, 13)\n",
    "param_grid = dict(gamma=gamma_range, C=C_range)\n",
    "grid_svm = GridSearchCV(SVC(), param_grid=param_grid, cv=5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'gamma': array([1.e-09, 1.e-08, 1.e-07, 1.e-06, 1.e-05, 1.e-04, 1.e-03, 1.e-02,\n",
      "       1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03]), 'C': array([1.e-02, 1.e-01, 1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05,\n",
      "       1.e+06, 1.e+07, 1.e+08, 1.e+09, 1.e+10])}\n"
     ]
    }
   ],
   "source": [
    "print (param_grid)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The best parameters are {'C': 10.0, 'gamma': 0.1} with a score of 0.98\n"
     ]
    }
   ],
   "source": [
    "# SVM\n",
    "grid_svm.fit(train_set, train_classes)\n",
    "print(\"The best parameters are %s with a score of %0.2f\"\n",
    "      % (grid_svm.best_params_, grid_svm.best_score_))\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Save / Load Trained Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['trained_grid_SVM.joblib']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Save\n",
    "joblib.dump(grid_svm, 'trained_grid_SVM.joblib')\n",
    "#Load\n",
    "#svclassifier = joblib.load('trained_grid_SVM.joblib') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Predict using the Test Set\n",
    "predicted_labels = grid_svm.predict(test_set)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recall:  [1.   1.   0.96 1.   1.   1.  ]\n",
      "Precision:  [1.         1.         1.         1.         0.96153846 1.        ]\n",
      "F1-Score:  [1.         1.         0.97959184 1.         0.98039216 1.        ]\n",
      "Accuracy: 0.99  , 149\n",
      "Number of samples: 150\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00        25\n",
      "           1       1.00      1.00      1.00        25\n",
      "           2       1.00      0.96      0.98        25\n",
      "           3       1.00      1.00      1.00        25\n",
      "           4       0.96      1.00      0.98        25\n",
      "           5       1.00      1.00      1.00        25\n",
      "\n",
      "   micro avg       0.99      0.99      0.99       150\n",
      "   macro avg       0.99      0.99      0.99       150\n",
      "weighted avg       0.99      0.99      0.99       150\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Recall - the ability of the classifier to find all the positive samples\n",
    "print(\"Recall: \", recall_score(test_classes, predicted_labels,average=None))\n",
    "\n",
    "# Precision - The precision is intuitively the ability of the classifier not to \n",
    "#label as positive a sample that is negative\n",
    "print(\"Precision: \", precision_score(test_classes, predicted_labels,average=None))\n",
    "\n",
    "# F1-Score - The F1 score can be interpreted as a weighted average of the precision \n",
    "#and recall\n",
    "print(\"F1-Score: \", f1_score(test_classes, predicted_labels, average=None))\n",
    "\n",
    "# Accuracy - the number of correctly classified samples\n",
    "print(\"Accuracy: %.2f  ,\" % accuracy_score(test_classes, predicted_labels,normalize=True), accuracy_score(test_classes, predicted_labels,normalize=False) )\n",
    "print(\"Number of samples:\",test_classes.shape[0])\n",
    "\n",
    "print(classification_report(test_classes, predicted_labels))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Compute confusion matrix\n",
    "cnf_matrix = confusion_matrix(test_classes, predicted_labels)\n",
    "np.set_printoptions(precision=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function to Plot Confusion Matrix\n",
    "# http://scikit-learn.org/stable/auto_examples/model_selection/plot_confusion_matrix.html\n",
    "def plot_confusion_matrix(cm, classes,\n",
    "                          normalize=False,\n",
    "                          title='Confusion matrix',\n",
    "                          cmap=plt.cm.Blues):\n",
    "    \"\"\"\n",
    "    This function prints and plots the confusion matrix.\n",
    "    Normalization can be applied by setting `normalize=True`.\n",
    "    \n",
    "    if normalize:\n",
    "        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n",
    "        print(\"Normalized confusion matrix\")\n",
    "    else:\n",
    "        print('Confusion matrix, without normalization')\n",
    "    \"\"\"\n",
    "    #print(cm)\n",
    "\n",
    "    plt.imshow(cm, interpolation='nearest', cmap=cmap)\n",
    "    plt.title(title)\n",
    "    plt.colorbar()\n",
    "    tick_marks = np.arange(len(classes))\n",
    "    plt.xticks(tick_marks, classes, rotation=45)\n",
    "    plt.yticks(tick_marks, classes)\n",
    "\n",
    "    fmt = '.2f' if normalize else 'd'\n",
    "    thresh = cm.max() / 2.\n",
    "    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):\n",
    "        plt.text(j, i, format(cm[i, j], fmt),\n",
    "                 horizontalalignment=\"center\",\n",
    "                 color=\"white\" if cm[i, j] > thresh else \"black\")\n",
    "\n",
    "    plt.tight_layout()\n",
    "    plt.ylabel('True label')\n",
    "    plt.xlabel('Predicted label')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x936 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot non-normalized confusion matrix\n",
    "classes=['flute','sax','oboe', 'cello','trumpet','viola']\n",
    "plt.figure(figsize=(18,13))\n",
    "plot_confusion_matrix(cnf_matrix, classes=classes,\n",
    "                      title='Confusion matrix, without normalization')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
